home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / b / ckiutl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-06  |  12.5 KB  |  499 lines
  1. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  2. /* |_o_o|\\ Copyright (c) 1986 The Software Distillery.  All Rights Reserved */
  3. /* |. o.| || This program may not be distributed without the permission of   */
  4. /* | .  | || the authors.                                                    */
  5. /* | o  | ||    Dave Baker     Ed Burnette  Stan Chow    Jay Denebeim        */
  6. /* |  . |//     Gordon Keener  Jack Rouse   John Toebes  Doug Walker         */
  7. /* ======          BBS:(919)-471-6436      VOICE:(919)-469-4210              */ 
  8. /*                                                                           */
  9. /* Contributed to Columbia University for inclusion in C-Kermit.             */
  10. /*
  11.   Permission is granted to any individual or institution to use this
  12.   software as long as it is not sold for profit.  This copyright notice must be
  13.   retained.  This software may not be included in commercial products without
  14.   written permission of Columbia University.
  15. */
  16. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  17.  
  18. /*  C K I U T L -- July 17, 1986
  19.  * Utility functions for C-Kermit on the Amiga
  20.  */
  21.  
  22. #ifndef _lint
  23. static char *ckuv = "Amiga utility functions, $Id: ckiutl.c,v 1.9 93/08/03 08:37:10 swalton Exp Locker: swalton $";
  24. #endif
  25.  
  26. /*
  27.  Author: Jack Rouse, The Software Distillery
  28.  
  29.  The file status routines assume all file protection modes are real, instead
  30.  of just delete protection on files and write protection on disks.
  31.  
  32.  $Log:    ckiutl.c,v $
  33.  * Revision 1.9  93/08/03  08:37:10  swalton
  34.  * Changes from Olaf Barthel:  Use standard include files and add handling
  35.  * for the NIL: handler
  36.  * 
  37.  * Revision 1.8  92/10/30  16:18:58  swalton
  38.  * Added code to call the V37 routine System() rather than the old Execute()
  39.  * routine in the system() utility.  It is conditional on the extern int
  40.  * v37 being TRUE.  This value is set in ckitio.c.
  41.  * 
  42.  * Revision 1.7  92/01/15  17:15:22  swalton
  43.  * Use Id rather than Header in the RCS ID string.
  44.  * 
  45.  * Revision 1.6  91/07/18  16:05:28  swalton
  46.  * pipeopen() fixed---it was inadvertently broken somewhere.  A system()
  47.  * call was written to replace the no-longer-working Manx one.  Both
  48.  * pipeopen() and system() will use the new AmigaOS System() call if
  49.  * the switch V37 was defined to be non-zero when Kermit was compiled.
  50.  * 
  51.  * Revision 1.5  91/05/29  09:09:21  swalton
  52.  * 1.  Changed function definitions to prototype style.  Required adding
  53.  *     a few forward declarations.
  54.  * 2.  Removed includes of stdio.h, stdlib.h, and string.h, as they are
  55.  *     now pulled in by ckcdeb.h, provided we compile with -DCK_ANSILIBS.
  56.  * 
  57.  * Revision 1.4  90/11/19  21:47:38  swalton
  58.  * Modifications for compiling with SAS/C Version 5.10, courtesy of
  59.  * Larry Rosenman (ler@lerami.lonestar.org, ler on BIX)
  60.  * 
  61.  * Revision 1.3  90/11/07  14:42:33  swalton
  62.  * Version 1.3--released to world as first beta test version simultaneously
  63.  * with release of edit 5A(160).
  64.  * 
  65.  * Revision 1.2  90/08/10  10:05:01  swalton
  66.  * A few changes for edit 150 of C Kermit.  Also deleted the include of
  67.  * ckipro.h, as it is confusing and somewhat unnecessary right now.
  68.  * 
  69.  * Revision 1.1  90/07/12  22:31:24  swalton
  70.  * Minor changes were made to ckiutl.c, mainly to maintain Manx Aztec C
  71.  * compatibility.
  72.  * 
  73.  * Revision 1.0  90/04/30  11:54:40  swalton
  74.  * Initial revision
  75.  * 
  76. */
  77.  
  78. #include "ckcasc.h"            /* ASCII symbols */
  79. #include "ckcdeb.h"            /* Debug formats, typedefs, etc. */
  80. #include "ckcker.h"            /* Symbol definitions for Kermit */
  81. #include <string.h>
  82.  
  83. #include "exec/types.h"
  84. #include "exec/exec.h"
  85. #include "libraries/dos.h"
  86. #include "libraries/dosextens.h"
  87. #define fh_Interact fh_Port
  88. #define fh_Process  fh_Type
  89. #include "fcntl.h"
  90. #include "signal.h"
  91.  
  92. #include <clib/exec_protos.h>
  93. #include <clib/alib_protos.h>
  94. #include <clib/dos_protos.h>
  95.  
  96. #if __SASC
  97. #include <ios1.h>
  98. #include <time.h>
  99. #endif
  100.  
  101.  
  102. #ifdef AZTEC_C
  103. /* translate Unix file handle (0, 1, or 2) to AmigaDOS file handle */
  104. #define DOSFH(n) (_devtab[n].fd)
  105. /* translate Unix file handle (0, 1, or 2) to Aztec file handle */
  106. #define FILENO(n) (n)
  107. #endif
  108. #ifdef __SASC
  109. #define DOSFH(n) (chkufb(n)->ufbfh)
  110. #define FILENO(n) (n)
  111. #endif
  112.  
  113. /* Amiga Kermit externals (defined in ckitio.c) */
  114. extern struct Process *CurProc;
  115. extern struct CommandLineInterface *CurCLI;
  116.  
  117. /*
  118.  * CreatePacket -- allocate and set up a AmigaDOS packet
  119.  */
  120. struct DosPacket *
  121. CreatePacket(void)
  122. {
  123.     register struct StandardPacket *sp;
  124.  
  125.     sp = (struct StandardPacket *)
  126.          AllocMem((LONG)sizeof(struct StandardPacket),
  127.               (LONG)MEMF_PUBLIC|MEMF_CLEAR);
  128.     if (sp == NULL) return(NULL);
  129.     sp->sp_Pkt.dp_Link = &sp->sp_Msg;
  130.     sp->sp_Msg.mn_Node.ln_Type = NT_MESSAGE;
  131.     sp->sp_Msg.mn_Node.ln_Name = (char *)&sp->sp_Pkt;
  132.     sp->sp_Msg.mn_Length = sizeof(struct DosPacket);
  133.     return(&sp->sp_Pkt);
  134. }
  135.  
  136. /*
  137.  * DeletePacket -- deallocate packet from CreatePacket()
  138.  */
  139. void
  140. DeletePacket(struct DosPacket *pkt) {
  141.     FreeMem(pkt->dp_Link, (LONG)sizeof(struct StandardPacket));
  142. }
  143.  
  144. /*
  145.  * zsyscmd(cmd) -- execute a command.
  146.  *   Identical to system except it makes sure that all priveleges are off,
  147.  *   so cmd is executed as a system process.
  148.  */
  149. int system(const char *cmd);
  150.  
  151. int
  152. zsyscmd(char *cmd) {
  153.     return(system(cmd));
  154. }
  155.  
  156.  
  157.  
  158. /*
  159.  * readstat -- determine file's read status
  160.  *    returns -3 if file read protected
  161.  *    returns -2 if file is a directory
  162.  *    returns -1 if file doesn't exist
  163.  *    returns file size otherwise
  164.  */
  165. long
  166. readstat(char *name) {
  167.     BPTR lock;
  168.     struct FileInfoBlock *fib;
  169.     long size;
  170.  
  171.     /* locate the file */ 
  172.     if ((lock = Lock(name, (LONG)ACCESS_READ)) == 0) return(-1);
  173.  
  174.     /* allocate a file info block */
  175.     if ((fib = (struct FileInfoBlock *)malloc(sizeof(*fib))) == NULL)
  176.     {    size = -1; goto quit; }
  177.  
  178.     /* make sure it's not a directory */
  179.     if (!Examine(lock, fib) || fib->fib_DirEntryType >= 0)
  180.     {    size = -2; goto quit; }
  181.  
  182.     /* make sure it's readable */
  183.     if (fib->fib_Protection & FIBF_READ)
  184.     {    size = -3; goto quit; }
  185.  
  186.     size = fib->fib_Size;
  187. quit:
  188.     if (fib) free(fib);
  189.     UnLock(lock);
  190.     return(size);
  191. }
  192.  
  193. /*
  194.  * writestat -- determines file's write status
  195.  *    returns 0 if file should be writable, -1 otherwise
  196.  *
  197.  * The following logic is used to determine if a file is writable:
  198.  *    1.  If the file exists, it must not be write or delete protected.
  199.  *        (Delete protection subsumes write protection for overwriting.)
  200.  *    2.  The parent directory must not be write protected ???
  201.  *    3.  The volume that the parent directory resides on must be
  202.  *        validated and not write protected.
  203.  */
  204. int
  205. writestat(char *name) {
  206.     register char *p;
  207.     char *lastslash;
  208.     char path[100];
  209.     BPTR lock;
  210.     struct FileInfoBlock *fib;
  211.     struct InfoData *id = NULL;
  212.     int rc = -1;
  213.  
  214.     /* allocate a FileInfoBlock */
  215.     fib = (struct FileInfoBlock *)malloc(sizeof(*fib));
  216.     if (fib == NULL) goto quit;
  217.  
  218.     /* see if the file exists */
  219.     if ((lock = Lock(name, (LONG)ACCESS_READ)) != 0)
  220.     {
  221.         /* make sure it's not a directory or write protected */
  222.         if (!Examine(lock, fib) ||
  223.             fib->fib_DirEntryType >= 0 ||
  224.             (fib->fib_Protection & (FIBF_WRITE|FIBF_DELETE)) )
  225.             goto quit;
  226.         UnLock(lock);
  227.     } else if (IoErr() == ERROR_ACTION_NOT_KNOWN ||
  228.            stricmp(name, "NIL:") == 0) {
  229.         rc = 0;
  230.         goto quit;
  231.     }
  232.  
  233.     /* strip path from name */
  234.     lastslash = NULL;
  235.     for (p = path; *p = *name; ++p, ++name)
  236.         if (*p == '/' || *p == ':')
  237.             lastslash = p;
  238.  
  239.     /* make sure the path exists */
  240.     if (lastslash)
  241.     {
  242.         lastslash[1] = 0;
  243.         lock = Lock(path, (LONG)ACCESS_READ);
  244.     }
  245.     else
  246.         lock = (CurProc->pr_CurrentDir)
  247.                ? DupLock(CurProc->pr_CurrentDir)
  248.                : 0;
  249.  
  250.     /* make sure it is a directory that is not write protected */
  251.     if (lock == 0 || !Examine(lock, fib) ||
  252.         fib->fib_DirEntryType <= 0 ||
  253.         (fib->fib_Protection & FIBF_WRITE) )
  254.         goto quit;
  255.  
  256.     /* get device info */    
  257.     if ((id = (struct InfoData *)malloc(sizeof(*id))) == NULL) goto quit;
  258.  
  259.     /* make sure the disk is writeable */
  260.     if (Info(lock, id) && id->id_DiskState == ID_VALIDATED)
  261.         rc = 0;
  262.  
  263.     /* clean up */
  264. quit:
  265.     if (id) free(id);
  266.     if (fib) free(fib);
  267.     if (lock) UnLock(lock);
  268.         return(rc);
  269. }
  270.  
  271. #include <dos/dostags.h>
  272.  
  273. static struct TagItem MyTags[] = {
  274.    { SYS_Output, 0L},
  275.    { TAG_END, 0L}
  276. };
  277. extern short v37;
  278.  
  279. /*
  280.  * pipeopen -- execute command to read output like a file
  281.  */
  282. #define PIPEHOLDER "RAM:Pipe-Holder"
  283. FILE *
  284. pipeopen(char *command) {
  285.     BPTR fh;
  286.  
  287.     /* create holder file */
  288.     fh = Open(PIPEHOLDER, (LONG)MODE_NEWFILE);
  289.     if (fh == 0) return(0);
  290.     if (v37) {
  291.         /* execute the command */
  292.         MyTags[0].ti_Data = fh;
  293.         if (System(command, MyTags) != 0)
  294.             return NULL;
  295.     } else
  296.         Execute(command, 0, fh);
  297.  
  298.     /* close the holder file */
  299.     Close(fh);
  300.  
  301.     /* reopen it for input */
  302.     return(fopen(PIPEHOLDER, "r"));
  303. }
  304.  
  305. /*
  306.  * pipeclose -- clean up after pipe open
  307.  */
  308. void
  309. pipeclose(FILE *f) {
  310.     fclose(f);
  311.     DeleteFile(PIPEHOLDER);
  312. }
  313.  
  314. /*
  315.  * existobj -- return true if file system object exists
  316.  */
  317. int
  318. existobj(char *name) {
  319.     BPTR lock;
  320.  
  321.     if (*name == 0) return(CurProc->pr_CurrentDir != 0);
  322.     if ((lock = Lock(name, (LONG)ACCESS_READ)) == 0)
  323.         return(0);
  324.     UnLock(lock);
  325.     return(1);
  326. }
  327.  
  328. /* opendir handle structure */
  329. struct DirHandle {
  330.     struct FileInfoBlock fib;
  331.     BPTR lock;
  332. };
  333.  
  334. /*
  335.  * attempt to open a directory, fill in a handle structure
  336.  */
  337. struct DirHandle *
  338. opendir(char *name) {
  339.     BPTR lock;
  340.     struct DirHandle *dh;
  341.  
  342.     /* get lock on name ("" is current dir) */
  343.     lock = (*name != 0)        ? Lock(name, (LONG)ACCESS_READ) :
  344.            (CurProc->pr_CurrentDir) ? DupLock(CurProc->pr_CurrentDir)
  345.                     : 0;
  346.     if (lock == 0) return(NULL);
  347.     dh = (struct DirHandle *)malloc(sizeof(*dh));
  348.     if (dh == NULL)
  349.     {
  350.         UnLock(lock);
  351.         return(NULL);
  352.     }
  353.     if (!Examine(lock, &dh->fib) || dh->fib.fib_DirEntryType <= 0)
  354.     {
  355.         UnLock(lock);
  356.         free(dh);
  357.         return(NULL);
  358.     }
  359.     /* pass it into the caller's care */
  360.     dh->lock = lock;
  361.     return(dh);
  362. }
  363.  
  364. /*
  365.  * return name for next entry in dir
  366.  */
  367. char *
  368. readdir(struct DirHandle *dh) {
  369.     return(ExNext(dh->lock, &dh->fib) ? dh->fib.fib_FileName : NULL);
  370. }
  371.  
  372. /*
  373.  * finish accessing a directory
  374.  */
  375. void
  376. closedir(struct DirHandle *dh) {
  377.     UnLock(dh->lock);
  378.     free(dh);
  379. }
  380. #ifdef __SASC
  381. /***
  382.   Based on sendpkt.c from AmigaMail Volume 1, Page II-17ff.
  383.  
  384. ***/
  385.  
  386. LONG dos_packet(struct MsgPort *pid,LONG action, LONG a1, LONG a2,
  387.                                     LONG a3, LONG a4, LONG a5,
  388.                                     LONG a6, LONG a7)
  389. {
  390. struct MsgPort *replyport;
  391. struct StandardPacket *packet;
  392. LONG res1;
  393.  
  394. replyport=(struct MsgPort *)CreatePort(NULL,0);
  395. if (!replyport) return(NULL);
  396.  
  397. packet=(struct StandardPacket *)
  398.    AllocMem((long)sizeof(struct StandardPacket),MEMF_PUBLIC|MEMF_CLEAR);
  399.    if (!packet) {
  400.          DeletePort(replyport);
  401.          return(NULL);
  402.    }
  403.  
  404. packet->sp_Msg.mn_Node.ln_Name = (char *)&(packet->sp_Pkt);
  405. packet->sp_Pkt.dp_Link         = &(packet->sp_Msg);
  406. packet->sp_Pkt.dp_Port         = replyport;
  407. packet->sp_Pkt.dp_Type         = action;
  408.  
  409. packet->sp_Pkt.dp_Arg1         = a1;
  410. packet->sp_Pkt.dp_Arg2         = a2;
  411. packet->sp_Pkt.dp_Arg3         = a3;
  412. packet->sp_Pkt.dp_Arg4         = a4;
  413. packet->sp_Pkt.dp_Arg5         = a5;
  414. packet->sp_Pkt.dp_Arg6         = a6;
  415. packet->sp_Pkt.dp_Arg7         = a7;
  416.  
  417.  
  418. PutMsg(pid,(struct Message *)packet);
  419.  
  420. WaitPort(replyport);
  421.  
  422. GetMsg(replyport);
  423.  
  424. res1 = packet->sp_Pkt.dp_Res1;
  425.  
  426. FreeMem(packet,(long)sizeof(struct StandardPacket));
  427. DeletePort(replyport);
  428.  
  429. return(res1);
  430. }
  431.  
  432. /* Return 1 if `y' is a leap year, 0 otherwise.
  433.  */
  434.  
  435. static int
  436. leap (int y) {
  437.     y += 1900;
  438.     if (y % 400 == 0)
  439.         return (1);
  440.     if (y % 100 == 0)
  441.         return (0);
  442.     return (y % 4 == 0);
  443. }
  444.  
  445. /* Return the number of days between Jan 1, 1970 and the given
  446.  * broken-down time.
  447.  */
  448.  
  449. static int
  450. ndays (struct tm *p) {
  451.     register n = p->tm_mday;
  452.     register m, y;
  453.     register char *md = "\37\34\37\36\37\36\37\37\36\37\36\37";
  454.  
  455.     for (y = 70; y < p->tm_year; ++y) {
  456.         n += 365;
  457.         if (leap (y)) ++n;
  458.     }
  459.     for (m = 0; m < p->tm_mon; ++m)
  460.         n += md[m] + (m == 1 && leap (y));
  461.     return (n);
  462. }
  463.  
  464. /* Convert a broken-down time (such as returned by localtime())
  465.  * back into a `time_t'.
  466.  */
  467.  
  468. time_t
  469. mktime(struct tm *tp) {
  470.     register int m1, m2;
  471.     time_t t;
  472.     struct tm otm;
  473.  
  474.     t = (ndays (tp) - 1) * 86400L + tp->tm_hour * 3600L
  475.         + tp->tm_min * 60 + tp->tm_sec;
  476.     /*
  477.      * Now the hard part -- correct for the time zone:
  478.      */
  479.     otm = *tp;
  480.     tp = localtime (&t);
  481.     m1 = tp->tm_hour * 60 + tp->tm_min;
  482.     m2 = otm.tm_hour * 60 + otm.tm_min;
  483.     t -= ((m1 - m2 + 720 + 1440) % 1440 - 720) * 60L;
  484.     return (t);
  485. }
  486. #endif
  487.  
  488. int
  489. system(const char *command) {
  490.     debug(F110, "system called with command", command, 0L);
  491.        if (v37) {
  492.         MyTags[0].ti_Data = DOSFH(1);
  493.            return(System((UBYTE *)  command, MyTags));
  494.        } else {
  495.         Execute((UBYTE *) command, 0, DOSFH(1));
  496.         return 0;
  497.     }
  498. }
  499.